home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / haziran / 19 / setup.exe / data.z / amcclib.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-04-11  |  21.4 KB  |  713 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - AMCCLIB.C
  3. //
  4. // Library for 'WinDriver for AMCC 5933' API. 
  5. // The basic idea is to get a handle for the board
  6. // with AMCC_Open() and use it in the rest of the program
  7. // when calling WD functions.  Call AMCC_Close() when done.
  8. // 
  9. ////////////////////////////////////////////////////////////////
  10.  
  11. #include "../../include/windrvr.h"
  12. #include "../../include/windrvr_int_thread.h"
  13. #include "amcclib.h"
  14. #include <stdio.h>
  15. #if !defined(WINCE)
  16.     #include <time.h>
  17. #else
  18.     extern time_t time();
  19. #endif
  20.  
  21. // this string is set to an error message, if one occurs
  22. CHAR AMCC_ErrorString[1024];
  23.  
  24. // internal function used by AMCC_Open()
  25. BOOL AMCC_DetectCardElements(AMCCHANDLE hAmcc);
  26.  
  27. DWORD AMCC_CountCards (DWORD dwVendorID, DWORD dwDeviceID)
  28. {
  29.     WD_VERSION ver;
  30.     WD_PCI_SCAN_CARDS pciScan;
  31.     HANDLE hWD = INVALID_HANDLE_VALUE;
  32.  
  33.     AMCC_ErrorString[0] = '\0';
  34.     hWD = WD_Open();
  35.     // check if handle valid & version OK
  36.     if (hWD==INVALID_HANDLE_VALUE) 
  37.     {
  38.         sprintf( AMCC_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  39.         return 0;
  40.     }
  41.  
  42.     BZERO(ver);
  43.     WD_Version(hWD,&ver);
  44.     if (ver.dwVer<WD_VER) 
  45.     {
  46.         sprintf( AMCC_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  47.         WD_Close (hWD);
  48.         return 0;
  49.     }
  50.  
  51.     BZERO(pciScan);
  52.     pciScan.searchId.dwVendorId = dwVendorID;
  53.     pciScan.searchId.dwDeviceId = dwDeviceID;
  54.     WD_PciScanCards (hWD, &pciScan);
  55.     WD_Close (hWD);
  56.     if (pciScan.dwCards==0)
  57.         sprintf( AMCC_ErrorString, "no cards found\n");
  58.     return pciScan.dwCards;
  59. }
  60.  
  61. BOOL AMCC_Open (AMCCHANDLE *phAmcc, DWORD dwVendorID, DWORD dwDeviceID, DWORD nCardNum, DWORD dwOptions)
  62. {
  63.     AMCCHANDLE hAmcc = (AMCCHANDLE) malloc (sizeof (AMCC_STRUCT));
  64.  
  65.     WD_VERSION ver;
  66.     WD_PCI_SCAN_CARDS pciScan;
  67.     WD_PCI_CARD_INFO pciCardInfo;
  68.  
  69.     *phAmcc = NULL;
  70.     AMCC_ErrorString[0] = '\0';
  71.     BZERO(*hAmcc);
  72.  
  73.     hAmcc->hWD = WD_Open();
  74.  
  75.     // check if handle valid & version OK
  76.     if (hAmcc->hWD==INVALID_HANDLE_VALUE) 
  77.     {
  78.         sprintf( AMCC_ErrorString, "Failed opening " WD_PROD_NAME " device\n");
  79.         goto Exit;
  80.     }
  81.  
  82.     BZERO(ver);
  83.     WD_Version(hAmcc->hWD,&ver);
  84.     if (ver.dwVer<WD_VER) 
  85.     {
  86.         sprintf( AMCC_ErrorString, "Incorrect " WD_PROD_NAME " version\n");
  87.         goto Exit;
  88.     }
  89.  
  90.     BZERO(pciScan);
  91.     pciScan.searchId.dwVendorId = dwVendorID;
  92.     pciScan.searchId.dwDeviceId = dwDeviceID;
  93.     WD_PciScanCards (hAmcc->hWD, &pciScan);
  94.     if (pciScan.dwCards==0) // Found at least one card
  95.     {
  96.         sprintf( AMCC_ErrorString, "Could not find PCI card\n");
  97.         goto Exit;
  98.     }
  99.     if (pciScan.dwCards<=nCardNum)
  100.     {
  101.         sprintf( AMCC_ErrorString, "Card out of range of available cards\n");
  102.         goto Exit;
  103.     }
  104.  
  105.     BZERO(pciCardInfo);
  106.     pciCardInfo.pciSlot = pciScan.cardSlot[nCardNum];
  107.     WD_PciGetCardInfo (hAmcc->hWD, &pciCardInfo);
  108.     hAmcc->pciSlot = pciCardInfo.pciSlot;
  109.     hAmcc->cardReg.Card = pciCardInfo.Card;
  110.  
  111.     hAmcc->fUseInt = (dwOptions & AMCC_OPEN_USE_INT) ? TRUE : FALSE;
  112.     if (!hAmcc->fUseInt)
  113.     {
  114.         DWORD i;
  115.         // Remove interrupt item if not needed
  116.         for (i=0; i<hAmcc->cardReg.Card.dwItems; i++)
  117.         {
  118.             WD_ITEMS *pItem = &hAmcc->cardReg.Card.Item[i];
  119.             if (pItem->item==ITEM_INTERRUPT)
  120.                 pItem->item = ITEM_NONE;
  121.         }
  122.     }
  123.     else
  124.     {
  125.         DWORD i;
  126.         // make interrupt resource sharable
  127.         for (i=0; i<hAmcc->cardReg.Card.dwItems; i++)
  128.         {
  129.             WD_ITEMS *pItem = &hAmcc->cardReg.Card.Item[i];
  130.             if (pItem->item==ITEM_INTERRUPT)
  131.                 pItem->fNotSharable = FALSE;
  132.         }
  133.     }
  134.  
  135.     hAmcc->cardReg.fCheckLockOnly = FALSE;
  136.     WD_CardRegister (hAmcc->hWD, &hAmcc->cardReg);
  137.     if (hAmcc->cardReg.hCard==0)
  138.     {
  139.         sprintf ( AMCC_ErrorString, "Failed locking device\n");
  140.         goto Exit;
  141.     }
  142.  
  143.     if (!AMCC_DetectCardElements(hAmcc))
  144.     {
  145.         sprintf ( AMCC_ErrorString, "Card does not have all items expected for AMCC\n");
  146.         goto Exit;
  147.     }
  148.  
  149.     // Open finished OK
  150.     *phAmcc = hAmcc;
  151.     return TRUE;
  152.  
  153. Exit:
  154.     // Error durin Open
  155.     if (hAmcc->cardReg.hCard) 
  156.         WD_CardUnregister(hAmcc->hWD, &hAmcc->cardReg);
  157.     if (hAmcc->hWD!=INVALID_HANDLE_VALUE)
  158.         WD_Close(hAmcc->hWD);
  159.     free (hAmcc);
  160.     return FALSE;
  161. }
  162.  
  163. DWORD AMCC_ReadPCIReg(AMCCHANDLE hAmcc, DWORD dwReg)
  164. {
  165.     WD_PCI_CONFIG_DUMP pciCnf;
  166.     DWORD dwVal;
  167.  
  168.     BZERO(pciCnf);
  169.     pciCnf.pciSlot = hAmcc->pciSlot;
  170.     pciCnf.pBuffer = &dwVal;
  171.     pciCnf.dwOffset = dwReg;
  172.     pciCnf.dwBytes = 4;
  173.     pciCnf.fIsRead = TRUE;
  174.     WD_PciConfigDump(hAmcc->hWD,&pciCnf);
  175.     return dwVal;
  176. }
  177.  
  178. void AMCC_WritePCIReg(AMCCHANDLE hAmcc, DWORD dwReg, DWORD dwData)
  179. {
  180.     WD_PCI_CONFIG_DUMP pciCnf;
  181.  
  182.     BZERO (pciCnf);
  183.     pciCnf.pciSlot = hAmcc->pciSlot;
  184.     pciCnf.pBuffer = &dwData;
  185.     pciCnf.dwOffset = dwReg;
  186.     pciCnf.dwBytes = 4;
  187.     pciCnf.fIsRead = FALSE;
  188.     WD_PciConfigDump(hAmcc->hWD,&pciCnf);
  189. }
  190.  
  191. BOOL AMCC_DetectCardElements(AMCCHANDLE hAmcc)
  192. {
  193.     DWORD i;
  194.     DWORD ad_sp;
  195.  
  196.     BZERO(hAmcc->Int);
  197.     BZERO(hAmcc->addrDesc);
  198.  
  199.     for (i=0; i<hAmcc->cardReg.Card.dwItems; i++)
  200.     {
  201.         WD_ITEMS *pItem = &hAmcc->cardReg.Card.Item[i];
  202.  
  203.         switch (pItem->item)
  204.         {
  205.         case ITEM_MEMORY:
  206.         case ITEM_IO:
  207.             {
  208.                 DWORD dwBytes;
  209.                 DWORD dwAddr;
  210.                 DWORD dwPhysAddr;
  211.                 DWORD dwAddrDirect = 0;
  212.                 BOOL fIsMemory;
  213.                 if (pItem->item==ITEM_MEMORY)
  214.                 {
  215.                     dwBytes = pItem->I.Mem.dwBytes;
  216.                     dwAddr = pItem->I.Mem.dwTransAddr;
  217.                     dwAddrDirect = pItem->I.Mem.dwUserDirectAddr;
  218.                     dwPhysAddr = pItem->I.Mem.dwPhysicalAddr;
  219.                     fIsMemory = TRUE;
  220.                 }
  221.                 else 
  222.                 {
  223.                     dwBytes = pItem->I.IO.dwBytes;
  224.                     dwAddr = pItem->I.IO.dwAddr;
  225.                     dwPhysAddr = dwAddr & 0xffff;
  226.                     fIsMemory = FALSE;
  227.                 }
  228.  
  229.                 for (ad_sp=AMCC_ADDR_REG; ad_sp<=AMCC_ADDR_NOT_USED; ad_sp++)
  230.                 {
  231.                     DWORD dwPCIAddr;
  232.  
  233.                     if (hAmcc->addrDesc[ad_sp].dwAddr) continue;
  234.                     dwPCIAddr = AMCC_ReadPCIReg(hAmcc, PCI_BAR0 + ad_sp*4);
  235.                     if (dwPCIAddr & 1)
  236.                     {
  237.                         if (fIsMemory) continue;
  238.                         dwPCIAddr &= ~0x3;
  239.                     }
  240.                     else
  241.                     {
  242.                         if (!fIsMemory) continue;
  243.                         dwPCIAddr &= ~0xf;
  244.                     }
  245.                     if (dwPCIAddr==dwPhysAddr)
  246.                         break;
  247.                 }
  248.                 if (ad_sp<=AMCC_ADDR_NOT_USED)
  249.                 {
  250.                     DWORD j;
  251.                     hAmcc->addrDesc[ad_sp].dwBytes = dwBytes;
  252.                     hAmcc->addrDesc[ad_sp].dwAddr = dwAddr;
  253.                     hAmcc->addrDesc[ad_sp].dwAddrDirect = dwAddrDirect;
  254.                     hAmcc->addrDesc[ad_sp].fIsMemory = fIsMemory;
  255.                     hAmcc->addrDesc[ad_sp].dwMask = 0;
  256.                     for (j=1; j<hAmcc->addrDesc[ad_sp].dwBytes && j!=0x80000000; j *= 2)
  257.                     {
  258.                         hAmcc->addrDesc[ad_sp].dwMask = 
  259.                             (hAmcc->addrDesc[ad_sp].dwMask << 1) | 1;
  260.                     }
  261.                 }
  262.             }
  263.             break;
  264.         case ITEM_INTERRUPT:
  265.             if (hAmcc->Int.Int.hInterrupt) return FALSE;
  266.             hAmcc->Int.Int.hInterrupt = pItem->I.Int.hInterrupt;
  267.             break;
  268.         }
  269.     }
  270.  
  271.     // check that all the items needed were found
  272.     // check if interrupt found
  273.     if (hAmcc->fUseInt && !hAmcc->Int.Int.hInterrupt) 
  274.     {
  275.         return FALSE;
  276.     }
  277.  
  278.     // check that the registers space was found
  279.     if (!AMCC_IsAddrSpaceActive(hAmcc, AMCC_ADDR_REG))
  280.         return FALSE;
  281.  
  282.     // check that at least one memory space was found
  283.     //for (i = AMCC_ADDR_SPACE0; i<=AMCC_ADDR_NOT_USED; i++)
  284.     //    if (AMCC_IsAddrSpaceActive(hAmcc, i)) break;
  285.     //if (i>AMCC_ADDR_NOT_USED) return FALSE;
  286.  
  287.     return TRUE;
  288. }
  289.  
  290. void AMCC_Close(AMCCHANDLE hAmcc)
  291. {
  292.     // disable interrupts
  293.     if (AMCC_IntIsEnabled(hAmcc))
  294.         AMCC_IntDisable(hAmcc);
  295.  
  296.     // unregister card
  297.     if (hAmcc->cardReg.hCard) 
  298.         WD_CardUnregister(hAmcc->hWD, &hAmcc->cardReg);
  299.  
  300.     // close WinDriver
  301.     WD_Close(hAmcc->hWD);
  302.  
  303.     free (hAmcc);
  304. }
  305.  
  306. BOOL AMCC_IsAddrSpaceActive(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace)
  307. {
  308.     return hAmcc->addrDesc[addrSpace].dwAddr!=0;
  309. }
  310.  
  311. void AMCC_WriteRegDWord (AMCCHANDLE hAmcc, DWORD dwReg, DWORD data)
  312. {
  313.     AMCC_WriteDWord (hAmcc, AMCC_ADDR_REG, dwReg, data);
  314. }
  315.  
  316. DWORD AMCC_ReadRegDWord (AMCCHANDLE hAmcc, DWORD dwReg)
  317. {
  318.     return AMCC_ReadDWord (hAmcc, AMCC_ADDR_REG, dwReg);
  319. }
  320.  
  321. void AMCC_WriteRegWord (AMCCHANDLE hAmcc, DWORD dwReg, WORD data)
  322. {
  323.     AMCC_WriteWord (hAmcc, AMCC_ADDR_REG, dwReg, data);
  324. }
  325.  
  326. WORD AMCC_ReadRegWord (AMCCHANDLE hAmcc, DWORD dwReg)
  327. {
  328.     return AMCC_ReadWord (hAmcc, AMCC_ADDR_REG, dwReg);
  329. }
  330.  
  331. void AMCC_WriteRegByte (AMCCHANDLE hAmcc, DWORD dwReg, BYTE data)
  332. {
  333.     AMCC_WriteByte (hAmcc, AMCC_ADDR_REG, dwReg, data);
  334. }
  335.  
  336. BYTE AMCC_ReadRegByte (AMCCHANDLE hAmcc, DWORD dwReg)
  337. {
  338.     return AMCC_ReadByte (hAmcc, AMCC_ADDR_REG, dwReg);
  339. }
  340.  
  341. // performs a single 32 bit write from address space
  342. void AMCC_WriteDWord(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr, DWORD data)
  343. {
  344.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  345.     {
  346.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  347.         DWORD *pDword = (DWORD *) dwAddr;
  348.         *pDword = data;
  349.     }
  350.     else
  351.     {
  352.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  353.         WD_TRANSFER trans;
  354.         BZERO(trans);
  355.         trans.cmdTrans = WP_DWORD;
  356.         trans.dwPort = dwAddr;
  357.         trans.Data.Dword = data;
  358.         WD_Transfer (hAmcc->hWD, &trans);
  359.     }
  360. }
  361.  
  362. // performs a single 32 bit read from address space
  363. DWORD AMCC_ReadDWord(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr)
  364. {
  365.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  366.     {
  367.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  368.         DWORD *pDword = (DWORD *) dwAddr;
  369.         return *pDword;
  370.     }
  371.     else
  372.     {
  373.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  374.         WD_TRANSFER trans;
  375.         BZERO(trans);
  376.         trans.cmdTrans = RP_DWORD;
  377.         trans.dwPort = dwAddr;
  378.         WD_Transfer (hAmcc->hWD, &trans);
  379.         return trans.Data.Dword;
  380.     }
  381. }
  382.  
  383. // performs a single 16 bit write from address space
  384. void AMCC_WriteWord(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr, WORD data)
  385. {
  386.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  387.     {
  388.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  389.         WORD *pWord = (WORD *) dwAddr;
  390.         *pWord = data;
  391.     }
  392.     else
  393.     {
  394.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  395.         WD_TRANSFER trans;
  396.         BZERO(trans);
  397.         trans.cmdTrans = WP_WORD;
  398.         trans.dwPort = dwAddr;
  399.         trans.Data.Word = data;
  400.         WD_Transfer (hAmcc->hWD, &trans);
  401.     }
  402. }
  403.  
  404. // performs a single 16 bit read from address space
  405. WORD AMCC_ReadWord(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr)
  406. {
  407.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  408.     {
  409.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  410.         WORD *pWord = (WORD *) dwAddr;
  411.         return *pWord;
  412.     }
  413.     else
  414.     {
  415.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  416.         WD_TRANSFER trans;
  417.         BZERO(trans);
  418.         trans.cmdTrans = RP_WORD;
  419.         trans.dwPort = dwAddr;
  420.         WD_Transfer (hAmcc->hWD, &trans);
  421.         return trans.Data.Word;
  422.     }
  423. }
  424.  
  425. // performs a single 8 bit write from address space
  426. void AMCC_WriteByte(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr, BYTE data)
  427. {
  428.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  429.     {
  430.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  431.         BYTE *pByte = (BYTE *) dwAddr;
  432.         *pByte = data;
  433.     }
  434.     else
  435.     {
  436.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  437.         WD_TRANSFER trans;
  438.         BZERO(trans);
  439.         trans.cmdTrans = WP_BYTE;
  440.         trans.dwPort = dwAddr;
  441.         trans.Data.Byte = data;
  442.         WD_Transfer (hAmcc->hWD, &trans);
  443.     }
  444. }
  445.  
  446. // performs a single 8 bit read from address space
  447. BYTE AMCC_ReadByte(AMCCHANDLE hAmcc, AMCC_ADDR addrSpace, DWORD dwLocalAddr)
  448. {
  449.     if (hAmcc->addrDesc[addrSpace].fIsMemory)
  450.     {
  451.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddrDirect + dwLocalAddr;
  452.         BYTE *pByte = (BYTE *) dwAddr;
  453.         return *pByte;
  454.     }
  455.     else
  456.     {
  457.         DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr + dwLocalAddr;
  458.         WD_TRANSFER trans;
  459.         BZERO(trans);
  460.         trans.cmdTrans = RP_BYTE;
  461.         trans.dwPort = dwAddr;
  462.         WD_Transfer (hAmcc->hWD, &trans);
  463.         return trans.Data.Byte;
  464.     }
  465. }
  466.  
  467. void AMCC_ReadWriteSpaceBlock (AMCCHANDLE hAmcc, DWORD dwOffset, PVOID buf, 
  468.                     DWORD dwBytes, BOOL fIsRead, AMCC_ADDR addrSpace, AMCC_MODE mode)
  469. {
  470.     WD_TRANSFER trans;
  471.     DWORD dwAddr = hAmcc->addrDesc[addrSpace].dwAddr +
  472.         (hAmcc->addrDesc[addrSpace].dwMask & dwOffset);
  473.  
  474.     BZERO(trans);
  475.     
  476.     if (hAmcc->addrDesc[addrSpace].fIsMemory) 
  477.     {
  478.         if (fIsRead) 
  479.         {
  480.             if (mode==AMCC_MODE_BYTE) trans.cmdTrans = RM_SBYTE;
  481.             else if (mode==AMCC_MODE_WORD) trans.cmdTrans = RM_SWORD;
  482.             else trans.cmdTrans = RM_SDWORD;
  483.         }
  484.         else 
  485.         {
  486.             if (mode==AMCC_MODE_BYTE) trans.cmdTrans = WM_SBYTE;
  487.             else if (mode==AMCC_MODE_WORD) trans.cmdTrans = WM_SWORD;
  488.             else trans.cmdTrans = WM_SDWORD;
  489.         }
  490.     }
  491.     else 
  492.     {
  493.         if (fIsRead) 
  494.         {
  495.             if (mode==AMCC_MODE_BYTE) trans.cmdTrans = RP_SBYTE;
  496.             else if (mode==AMCC_MODE_WORD) trans.cmdTrans = RP_SWORD;
  497.             else trans.cmdTrans = RP_SDWORD;
  498.         }
  499.         else 
  500.         {
  501.             if (mode==AMCC_MODE_BYTE) trans.cmdTrans = WP_SBYTE;
  502.             else if (mode==AMCC_MODE_WORD) trans.cmdTrans = WP_SWORD;
  503.             else trans.cmdTrans = WP_SDWORD;
  504.         }
  505.     }
  506.     trans.dwPort = dwAddr;
  507.     trans.fAutoinc = TRUE;
  508.     trans.dwBytes = dwBytes;
  509.     trans.dwOptions = 0;
  510.     trans.Data.pBuffer = buf;
  511.     WD_Transfer (hAmcc->hWD, &trans);
  512. }
  513.  
  514. void AMCC_ReadSpaceBlock (AMCCHANDLE hAmcc, DWORD dwOffset, PVOID buf, 
  515.                     DWORD dwBytes, AMCC_ADDR addrSpace)
  516. {
  517.     AMCC_ReadWriteSpaceBlock (hAmcc, dwOffset, buf, dwBytes, TRUE, addrSpace, AMCC_MODE_DWORD);
  518. }
  519.  
  520. void AMCC_WriteSpaceBlock (AMCCHANDLE hAmcc, DWORD dwOffset, PVOID buf, 
  521.                      DWORD dwBytes, AMCC_ADDR addrSpace)
  522. {
  523.     AMCC_ReadWriteSpaceBlock (hAmcc, dwOffset, buf, dwBytes, FALSE, addrSpace, AMCC_MODE_DWORD);
  524. }
  525.  
  526. //////////////////////////////////////////////////////////////////////////////
  527. // Interrupts
  528. //////////////////////////////////////////////////////////////////////////////
  529.  
  530. BOOL AMCC_IntIsEnabled (AMCCHANDLE hAmcc)
  531. {
  532.     if (!hAmcc->fUseInt) return FALSE;
  533.     if (!hAmcc->Int.hThread) return FALSE;
  534.     return TRUE;
  535. }
  536.  
  537. VOID AMCC_IntHandler (PVOID pData)
  538. {
  539.     AMCCHANDLE hAmcc = (AMCCHANDLE) pData;
  540.     AMCC_INT_RESULT intResult;
  541.  
  542.     intResult.dwCounter = hAmcc->Int.Int.dwCounter;
  543.     intResult.dwLost = hAmcc->Int.Int.dwLost;
  544.     intResult.fStopped = hAmcc->Int.Int.fStopped;
  545.     intResult.dwStatusReg = hAmcc->Int.Trans[0].Data.Dword;
  546.     hAmcc->Int.funcIntHandler(hAmcc, &intResult);
  547. }
  548.  
  549. BOOL AMCC_IntEnable (AMCCHANDLE hAmcc, AMCC_INT_HANDLER funcIntHandler)
  550. {
  551.     DWORD dwAddr;
  552.  
  553.     if (!hAmcc->fUseInt) return FALSE;
  554.     // check if interrupt is already enabled
  555.     if (hAmcc->Int.hThread) return FALSE;
  556.  
  557.     BZERO(hAmcc->Int.Trans);
  558.     // This is a samlpe of handling interrupts:
  559.     // Two transfer commands are issued. First the value of the interrrupt control/status
  560.     // register is read. Then, a value of ZERO is written.
  561.     // This will cancel interrupts after the first interrupt occurs.
  562.     // When using interrupts, this section will have to change:
  563.     // you must put transfer commands to CANCEL the source of the interrupt, otherwise, the 
  564.     // PC will hang when an interrupt occurs!
  565.     dwAddr = hAmcc->addrDesc[AMCC_ADDR_REG].dwAddr + INTCSR_ADDR;
  566.     hAmcc->Int.Trans[0].cmdTrans = hAmcc->addrDesc[AMCC_ADDR_REG].fIsMemory ? RM_DWORD : RP_DWORD;
  567.     hAmcc->Int.Trans[0].dwPort = dwAddr;
  568.     hAmcc->Int.Trans[1].cmdTrans = hAmcc->addrDesc[AMCC_ADDR_REG].fIsMemory ? WM_DWORD : WP_DWORD;
  569.     hAmcc->Int.Trans[1].dwPort = dwAddr;
  570.     hAmcc->Int.Trans[1].Data.Dword = 0x8cc000; // put here the data to write to the control register
  571.     hAmcc->Int.Int.dwCmds = 2; 
  572.     hAmcc->Int.Int.Cmd = hAmcc->Int.Trans;
  573.     hAmcc->Int.Int.dwOptions |= INTERRUPT_CMD_COPY;
  574.  
  575.     // this calls WD_IntEnable() and creates an interrupt handler thread
  576.     hAmcc->Int.funcIntHandler = funcIntHandler;
  577.     if (!InterruptThreadEnable(&hAmcc->Int.hThread, hAmcc->hWD, &hAmcc->Int.Int, AMCC_IntHandler, (PVOID) hAmcc))
  578.         return FALSE;
  579.     
  580.     // add here code to physically enable interrupts,
  581.     // by setting bits in the INTCSR_ADDR register
  582.  
  583.     return TRUE;
  584. }
  585.  
  586. void AMCC_IntDisable (AMCCHANDLE hAmcc)
  587. {
  588.     if (!hAmcc->fUseInt) return;
  589.     if (!hAmcc->Int.hThread) return;
  590.  
  591.     // add here code to physically disable interrupts,
  592.     // by clearing bits in the INTCSR_ADDR register
  593.  
  594.     // this calls WD_IntDisable()
  595.     InterruptThreadDisable(hAmcc->Int.hThread);
  596.  
  597.     hAmcc->Int.hThread = NULL;
  598. }
  599.  
  600. //////////////////////////////////////////////////////////////////////////////
  601. // NVRam
  602. //////////////////////////////////////////////////////////////////////////////
  603.  
  604. BOOL AMCC_WaitForNotBusy(AMCCHANDLE hAmcc)
  605. {
  606.     BOOL fReady = FALSE;
  607.     time_t timeStart = time(NULL);
  608.  
  609.     for (; !fReady; ) 
  610.     {
  611.         if ((AMCC_ReadRegByte(hAmcc, BMCSR_NVCMD_ADDR) & NVRAM_BUSY_BITS) != NVRAM_BUSY_BITS) 
  612.         {
  613.             fReady = TRUE;
  614.         }
  615.         else 
  616.         {
  617.             if ((time(NULL) - timeStart) > 1) /* More than 1 second? */
  618.                 break;
  619.         }
  620.     } 
  621.  
  622.     return fReady;
  623. }
  624.  
  625. BOOL AMCC_ReadNVByte(AMCCHANDLE hAmcc, DWORD dwAddr, BYTE *pbData)
  626. {
  627.     if (dwAddr >= AMCC_NVRAM_SIZE) return FALSE;
  628.     /* Access non-volatile memory */
  629.  
  630.     /* Wait for nvRAM not busy */
  631.     if (!AMCC_WaitForNotBusy(hAmcc)) return FALSE;
  632.  
  633.     /* Load Low address */
  634.     AMCC_WriteRegByte(hAmcc, BMCSR_NVCMD_ADDR, NVCMD_LOAD_LOW_BITS);
  635.     AMCC_WriteRegByte(hAmcc, BMCSR_NVDATA_ADDR, (BYTE) (dwAddr & 0xff));
  636.  
  637.     /* Load High address */
  638.     AMCC_WriteRegByte(hAmcc, BMCSR_NVCMD_ADDR, NVCMD_LOAD_HIGH_BITS);
  639.     AMCC_WriteRegByte(hAmcc, BMCSR_NVDATA_ADDR, (BYTE) (dwAddr >> 8));
  640.  
  641.     /* Send Begin Read command */
  642.     AMCC_WriteRegByte(hAmcc, BMCSR_NVCMD_ADDR, NVCMD_BEGIN_READ_BITS);
  643.  
  644.     /* Wait for nvRAM not busy */
  645.     if (!AMCC_WaitForNotBusy(hAmcc)) return FALSE;
  646.  
  647.     /* Get data from nvRAM Data register */
  648.     *pbData = AMCC_ReadRegByte(hAmcc, BMCSR_NVDATA_ADDR);
  649.  
  650.     return TRUE;
  651. }
  652.  
  653. //////////////////////////////////////////////////////////////////////////////
  654. // DMA
  655. //////////////////////////////////////////////////////////////////////////////
  656.  
  657. BOOL AMCC_DMAOpen(AMCCHANDLE hAmcc, WD_DMA *pDMA, DWORD dwBytes)
  658. {
  659.     AMCC_ErrorString[0] = '\0';
  660.     BZERO(*pDMA);
  661.     pDMA->pUserAddr = NULL; // the kernel will allocate the buffer
  662.     pDMA->dwBytes = dwBytes; // size of buffer to allocate
  663.     pDMA->dwOptions = DMA_KERNEL_BUFFER_ALLOC; 
  664.     WD_DMALock (hAmcc->hWD, pDMA);
  665.     if (!pDMA->hDma) 
  666.     {
  667.         sprintf ( AMCC_ErrorString, "Failed allocating the buffer!\n");
  668.         return FALSE;
  669.     }
  670.  
  671.     return TRUE;
  672. }
  673.  
  674. void AMCC_DMAClose(AMCCHANDLE hAmcc, WD_DMA *pDMA)
  675. {
  676.     WD_DMAUnlock (hAmcc->hWD, pDMA);
  677. }
  678.  
  679. BOOL AMCC_DMAStart(AMCCHANDLE hAmcc, WD_DMA *pDMA, BOOL fRead,
  680.     BOOL fBlocking, DWORD dwBytes, DWORD dwOffset)
  681. {
  682.     DWORD dwBMCSR;
  683.  
  684.     // Important note:
  685.     // fRead - if TRUE, data moved from the AMCC-card to the PC memory 
  686.     // fRead - if FALSE, data moved from the PC memory to the AMCC card
  687.     // the terms used by AMCC are oposite! 
  688.     // in AMCC terms - read operation is from PC memory to AMCC card
  689.     AMCC_WriteRegDWord(hAmcc, fRead ? MWAR_ADDR : MRAR_ADDR, (DWORD) pDMA->Page[0].pPhysicalAddr + dwOffset);
  690.     AMCC_WriteRegDWord(hAmcc, fRead ? MWTC_ADDR : MRTC_ADDR, dwBytes);
  691.     dwBMCSR = AMCC_ReadRegDWord(hAmcc, BMCSR_ADDR);
  692.     dwBMCSR |= fRead ? BIT10 : BIT14;
  693.     AMCC_WriteRegDWord(hAmcc, BMCSR_ADDR, dwBMCSR);
  694.     // if blocking then wait for transfer to complete
  695.     if (fBlocking)
  696.         while (!AMCC_DMAIsDone(hAmcc, fRead));
  697.  
  698.     return TRUE;
  699. }
  700.  
  701. BOOL AMCC_DMAIsDone(AMCCHANDLE hAmcc, BOOL fRead)
  702. {
  703.     DWORD dwBIT = fRead ? BIT18 : BIT19;
  704.     DWORD dwINTCSR = AMCC_ReadRegDWord(hAmcc, INTCSR_ADDR);
  705.     if (dwINTCSR & dwBIT)
  706.     {
  707.         AMCC_WriteRegDWord(hAmcc, INTCSR_ADDR, dwBIT);
  708.         return TRUE;
  709.     }
  710.     return FALSE;
  711. }
  712.  
  713.